package services

import (
	"errors"
	"time"

	"backend-api/internal/models"
	"backend-api/pkg/database"
	"backend-api/pkg/utils"

	"gorm.io/gorm"
)

// AdminService 管理员服务
type AdminService struct {
	db *gorm.DB
}

// NewAdminService 创建管理员服务实例
func NewAdminService() *AdminService {
	return &AdminService{
		db: database.GetDB(),
	}
}

// AdminLoginRequest 管理员登录请求
type AdminLoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

// AdminLoginResponse 管理员登录响应
type AdminLoginResponse struct {
	Token string                 `json:"token"`
	Admin *models.AdminResponse `json:"admin"`
}

// UserListRequest 用户列表请求
type UserListRequest struct {
	Page     int    `form:"page,default=1" binding:"min=1"`
	PageSize int    `form:"page_size,default=10" binding:"min=1,max=100"`
	Keyword  string `form:"keyword"`
	Status   *int   `form:"status"`
}

// UserListResponse 用户列表响应
type UserListResponse struct {
	List  []*models.UserResponse `json:"list"`
	Total int64                 `json:"total"`
	Page  int                   `json:"page"`
	Size  int                   `json:"size"`
}

// UpdateUserStatusRequest 更新用户状态请求
type UpdateUserStatusRequest struct {
	Status int `json:"status" binding:"oneof=0 1"`
}

// Login 管理员登录
func (s *AdminService) Login(req *AdminLoginRequest) (*AdminLoginResponse, error) {
	// 查找管理员
	var admin models.Admin
	if err := s.db.Where("username = ? OR email = ?", req.Username, req.Username).First(&admin).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("管理员不存在")
		}
		return nil, errors.New("查询管理员失败")
	}

	// 检查管理员状态
	if admin.Status == 0 {
		return nil, errors.New("管理员已被禁用")
	}

	// 验证密码
	if !utils.CheckPassword(req.Password, admin.Password) {
		return nil, errors.New("密码错误")
	}

	// 生成JWT令牌
	token, err := utils.GenerateAdminToken(admin.ID, admin.UUID, admin.Username)
	if err != nil {
		return nil, errors.New("生成令牌失败")
	}

	// 更新最后登录时间
	now := time.Now()
	admin.LastLogin = &now
	s.db.Save(&admin)

	return &AdminLoginResponse{
		Token: token,
		Admin: admin.ToResponse(),
	}, nil
}

// GetProfile 获取管理员信息
func (s *AdminService) GetProfile(adminID uint) (*models.AdminResponse, error) {
	var admin models.Admin
	if err := s.db.First(&admin, adminID).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("管理员不存在")
		}
		return nil, errors.New("查询管理员失败")
	}

	return admin.ToResponse(), nil
}

// GetUserList 获取用户列表
func (s *AdminService) GetUserList(req *UserListRequest) (*UserListResponse, error) {
	query := s.db.Model(&models.User{})

	// 关键词搜索
	if req.Keyword != "" {
		query = query.Where("username LIKE ? OR email LIKE ? OR nickname LIKE ?",
			"%"+req.Keyword+"%", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
	}

	// 状态筛选
	if req.Status != nil {
		query = query.Where("status = ?", *req.Status)
	}

	// 计算总数
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, errors.New("查询用户总数失败")
	}

	// 分页查询
	offset := (req.Page - 1) * req.PageSize
	var users []models.User
	if err := query.Offset(offset).Limit(req.PageSize).Order("created_at DESC").Find(&users).Error; err != nil {
		return nil, errors.New("查询用户列表失败")
	}

	// 转换为响应格式
	userList := make([]*models.UserResponse, len(users))
	for i, user := range users {
		userList[i] = user.ToResponse()
	}

	return &UserListResponse{
		List:  userList,
		Total: total,
		Page:  req.Page,
		Size:  req.PageSize,
	}, nil
}

// GetUserByID 根据ID获取用户详情
func (s *AdminService) GetUserByID(userID uint) (*models.UserResponse, error) {
	var user models.User
	if err := s.db.First(&user, userID).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户不存在")
		}
		return nil, errors.New("查询用户失败")
	}

	return user.ToResponse(), nil
}

// UpdateUserStatus 更新用户状态
func (s *AdminService) UpdateUserStatus(userID uint, status int) error {
	var user models.User
	if err := s.db.First(&user, userID).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("用户不存在")
		}
		return errors.New("查询用户失败")
	}

	user.Status = status
	if err := s.db.Save(&user).Error; err != nil {
		return errors.New("更新用户状态失败")
	}

	return nil
}

// DeleteUser 删除用户（软删除）
func (s *AdminService) DeleteUser(userID uint) error {
	var user models.User
	if err := s.db.First(&user, userID).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("用户不存在")
		}
		return errors.New("查询用户失败")
	}

	if err := s.db.Delete(&user).Error; err != nil {
		return errors.New("删除用户失败")
	}

	return nil
}